home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / contrib / pdcurs22 / src / portable / overlay.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-26  |  8.5 KB  |  277 lines
  1. /*
  2. ***************************************************************************
  3. * This file comprises part of PDCurses. PDCurses is Public Domain software.
  4. * You may use this code for whatever purposes you desire. This software
  5. * is provided AS IS with NO WARRANTY whatsoever.
  6. * Should this software be used in another application, an acknowledgement
  7. * that PDCurses code is used would be appreciated, but is not mandatory.
  8. *
  9. * Any changes which you make to this software which may improve or enhance
  10. * it, should be forwarded to the current maintainer for the benefit of 
  11. * other users.
  12. *
  13. * The only restriction placed on this code is that no distribution of
  14. * modified PDCurses code be made under the PDCurses name, by anyone
  15. * other than the current maintainer.
  16. * 
  17. * See the file maintain.er for details of the current maintainer.
  18. ***************************************************************************
  19. */
  20. #define    CURSES_LIBRARY    1
  21. #include <curses.h>
  22.  
  23. /* undefine any macros for functions defined in this module */
  24. #undef    overlay
  25. #undef    overwrite
  26. #undef    copywin
  27.  
  28. /* undefine any macros for functions called by this module if in debug mode */
  29. #ifdef PDCDEBUG
  30. #  undef    move
  31. #  undef    wmove
  32. #endif
  33.  
  34. #ifdef PDCDEBUG
  35. char *rcsid_overlay  = "$Id$";
  36. #endif
  37.  
  38. /*man-start*********************************************************************
  39.  
  40.   Name:                                                       overlay
  41.  
  42.   Synopsis:
  43.       int    overlay(WINDOW *src_w, WINDOW *dst_w)
  44.       int    overwrite(WINDOW *src_w, WINDOW *dst_w)
  45.       int    copywin(WINDOW *src_w, WINDOW *dst_w, int src_tr,
  46.               int src_tc, int dst_tr, int dst_tc, int dst_br, int dst_bc,
  47.               bool overlay)
  48.  
  49.   X/Open Description:
  50.      The overlay() and overwrite() functions overlay src_w on top of 
  51.      dst_w; that is, all text in src_w is copied into dst_w. The windows
  52.      src_w and dst_w are not required to be the same size. The
  53.      copy starts at (0, 0) on each window. The difference between
  54.      the two functions is that overlay() is non-destructive
  55.      (blanks are not copied) while overwrite() is destructive
  56.      (blanks are copied).
  57.  
  58.      copywin() is similar to overwrite() and overlay() but copywin()
  59.      does not require that the two windows overlap.
  60.      The arguments src_tc and src_tr specify the top left corner of the
  61.      region to be copied to the destination window.
  62.      The arguments dst_tc,dst_tr,dst_br,dst_bc specify the region within
  63.      the destination window to where the copy is made.
  64.      The argument overlay, if TRUE, indicates that the copy is done
  65.      non-destructively (as in overlay()). Blanks in the source window
  66.      are not copied to the destination window. When overlay is FALSE,
  67.      (as in overwrit()), the copy is destructive; blanks are copied
  68.      to the destination window.
  69.  
  70.   PDCurses Description:
  71.      The above description for overlay() and overwrite() is misleading 
  72.      in the actual behaviour exhibited by both SysV and BSD curses. 
  73.      The above implies that the character in 0,0 of the source window 
  74.      is copied to 0,0 of the destination window. What actually happens 
  75.      is that those characters in the source window that intersect with 
  76.      characters in the destination window RELATIVE TO ABSOLUTE 0,0 ON 
  77.      THE SCREEN, are copied to the destination window so that the 
  78.      characters appear in the same physical position on the screen.
  79.  
  80.      Thanks to Andreas Otte (venn@@uni-paderborn.de) for the correction
  81.      and code changes.
  82.  
  83.   X/Open Return Value:
  84.      All functions return OK on success and ERR on error.
  85.  
  86.   X/Open Errors:
  87.      No errors are defined for this function.
  88.  
  89.   Portability                             X/Open    BSD    SYS V
  90.                                           Dec '88
  91.       overlay                               Y        Y       Y
  92.       overwrite                             Y        Y       Y
  93.       copywin                               -        -      3.0
  94.  
  95. **man-end**********************************************************************/
  96.  
  97. /***********************************************************************/
  98. int    overlay(WINDOW *src_w, WINDOW *dst_w)
  99. /***********************************************************************/
  100. {
  101.     int    last_line;
  102.     int    last_col;
  103.     int    first_line;
  104.     int    first_col;
  105.     int    src_start_x;
  106.     int    src_start_y;
  107.     int    dst_start_x;
  108.     int    dst_start_y;
  109.     int    xdiff;
  110.     int    ydiff;
  111.     int    rc;
  112.  
  113. #ifdef PDCDEBUG
  114.     if (trace_on) PDC_debug("overlay() - called\n");
  115. #endif
  116.  
  117.     if (src_w == (WINDOW *)NULL)    return( ERR );
  118.     if (dst_w == (WINDOW *)NULL)    return( ERR );
  119.  
  120.     first_col  = max(dst_w->_begx,src_w->_begx);
  121.     first_line = max(dst_w->_begy,src_w->_begy);
  122.     last_col   = min(src_w->_begx+src_w->_maxx, dst_w->_begx+dst_w->_maxx);
  123.     last_line  = min(src_w->_begy+src_w->_maxy, dst_w->_begy+dst_w->_maxy);
  124.  
  125. /* determine the overlapping region of the two windows in real coordinates */
  126.     if ((last_col < first_col) || (last_line < first_line))
  127.     return(OK);  /* if no overlapping region, do nothing */
  128.  
  129. /* size of overlapping region */
  130.     xdiff = last_col - first_col;
  131.     ydiff = last_line - first_line;
  132.  
  133.     if (src_w->_begx <= dst_w->_begx)
  134.         {
  135.         src_start_x = dst_w->_begx - src_w->_begx;
  136.         dst_start_x = 0;
  137.         }
  138.     else
  139.         {
  140.         dst_start_x = src_w->_begx - dst_w->_begx;
  141.         src_start_x = 0;
  142.         }
  143.     if (src_w->_begy <= dst_w->_begy)
  144.         {
  145.         src_start_y = dst_w->_begy - src_w->_begy;
  146.         dst_start_y = 0;
  147.         }
  148.     else
  149.         {
  150.         dst_start_y = src_w->_begy - dst_w->_begy;
  151.         src_start_y = 0;
  152.         }
  153.  
  154.     rc = PDC_copy_win(src_w,dst_w,src_start_y,src_start_x,
  155.         src_start_y+ydiff,src_start_x+xdiff,dst_start_y,dst_start_x,
  156.         dst_start_y+ydiff,dst_start_x+xdiff,TRUE);
  157.  
  158.     return( rc );
  159. }
  160. /***********************************************************************/
  161. int    overwrite(WINDOW *src_w, WINDOW *dst_w)
  162. /***********************************************************************/
  163. {
  164.     int    last_line;
  165.     int    last_col;
  166.     int    first_line;
  167.     int    first_col;
  168.     int    src_start_x;
  169.     int    src_start_y;
  170.     int    dst_start_x;
  171.     int    dst_start_y;
  172.     int    xdiff;
  173.     int    ydiff;
  174.     int    rc;
  175.  
  176. #ifdef PDCDEBUG
  177.     if (trace_on) PDC_debug("overwrit() - called\n");
  178. #endif
  179.  
  180.     if (src_w == (WINDOW *)NULL)    return( ERR );
  181.     if (dst_w == (WINDOW *)NULL)    return( ERR );
  182.  
  183.     first_col  = max(dst_w->_begx,src_w->_begx);
  184.     first_line = max(dst_w->_begy,src_w->_begy);
  185.     last_col   = min(src_w->_begx+src_w->_maxx, dst_w->_begx+dst_w->_maxx);
  186.     last_line  = min(src_w->_begy+src_w->_maxy, dst_w->_begy+dst_w->_maxy);
  187.  
  188. /* determine the overlapping region of the two windows in real coordinates */
  189.     if ((last_col < first_col) || (last_line < first_line))
  190.     return(OK);  /* if no overlapping region, do nothing */
  191.  
  192. /* size of overlapping region */
  193.     xdiff = last_col - first_col;
  194.     ydiff = last_line - first_line;
  195.  
  196.     if (src_w->_begx <= dst_w->_begx)
  197.         {
  198.         src_start_x = dst_w->_begx - src_w->_begx;
  199.         dst_start_x = 0;
  200.         }
  201.     else
  202.         {
  203.         dst_start_x = src_w->_begx - dst_w->_begx;
  204.         src_start_x = 0;
  205.         }
  206.     if (src_w->_begy <= dst_w->_begy)
  207.         {
  208.         src_start_y = dst_w->_begy - src_w->_begy;
  209.         dst_start_y = 0;
  210.         }
  211.     else
  212.         {
  213.         dst_start_y = src_w->_begy - dst_w->_begy;
  214.         src_start_y = 0;
  215.         }
  216.  
  217.     rc = PDC_copy_win(src_w,dst_w,src_start_y,src_start_x,
  218.         src_start_y+ydiff,src_start_x+xdiff,dst_start_y,dst_start_x,
  219.         dst_start_y+ydiff,dst_start_x+xdiff,FALSE);
  220.  
  221.     return( rc );
  222. }
  223. /***********************************************************************/
  224. int    copywin(WINDOW *src_w, WINDOW *dst_w, int src_tr,
  225.              int src_tc, int dst_tr, int dst_tc, int dst_br, int dst_bc,
  226.              int overlay)
  227. /***********************************************************************/
  228. {
  229.     int    src_start_x = src_tc;
  230.     int    src_start_y = src_tr;
  231.     int    dst_start_x = dst_tc;
  232.     int    dst_start_y = dst_tr;
  233.     int    src_end_x;
  234.     int    src_end_y;
  235.     int    dst_end_x;
  236.     int    dst_end_y;
  237.     int    src_rows,src_cols;
  238.     int    dst_rows,dst_cols;
  239.     int    min_rows,min_cols;
  240.     int    max_rows,max_cols;
  241.     int    rc;
  242.  
  243. #ifdef PDCDEBUG
  244.     if (trace_on) PDC_debug("copywin() - called\n");
  245. #endif
  246.  
  247.     if (src_w == (WINDOW *)NULL
  248.     ||  dst_w == (WINDOW *)NULL)
  249.         return( ERR );
  250.  
  251.     if (dst_w == curscr)    return( ERR );
  252.  
  253.     if (dst_br >= dst_w->_maxy
  254.     ||  dst_bc >= dst_w->_maxx
  255.     ||  dst_tr < 0
  256.     ||  dst_tc < 0)
  257.         return( ERR );
  258.  
  259.     src_rows = src_w->_maxy - src_tr;
  260.     src_cols = src_w->_maxx - src_tc;
  261.     dst_rows = dst_br - dst_tr;
  262.     dst_cols = dst_bc - dst_tc;
  263.  
  264.     min_rows = min(src_rows,dst_rows);
  265.     min_cols = min(src_cols,dst_cols);
  266.  
  267.     src_end_y = src_tr + min_rows;
  268.     src_end_x = src_tc + min_cols;
  269.     dst_end_y = dst_tr + min_rows;
  270.     dst_end_x = dst_tc + min_cols;
  271.  
  272.     rc = PDC_copy_win(src_w,dst_w,src_start_y,src_start_x,src_end_y,src_end_x,
  273.         dst_start_y,dst_start_x,dst_end_y,dst_end_x,overlay);
  274.  
  275.     return( rc );
  276. }
  277.